// pages/notes/notes.js

const app = getApp();
const BaseURL = app.globalData.baseURL;

Page({
    /**
     * 页面的初始数据
     */
    data: {
        // 书籍信息
        bookInfo: {},
        // 笔记列表
        noteList: [],
        // 笔记数量
        noteCount: 0,
        // 笔记表单面板状态
        booknoteAddPannel_show: false,
        // 笔记输入框的值
        note: {
            article: '',
            section: '',
            title: '',
            content: '',
            create_date: ''
        },
        // 笔记是否处于新增状态（新增 | 修改）
        noteState_add: true,
        // 当笔记处于修改状态时获取的当前笔记的索引值
        noteIndex: 9999,
        // 接口文件
        apifile: {
            noteAdd: '',
            getInfo: '',
            databaseName: ''
        },
        // 对话框信息
        dialogInfo: {
            article: '',
            section: '',
            title: '',
            content: '',
            create_date: ''
        },
        dialogInfoShow: false
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad: function (options) {
        // 获取 this
        const _this = this;

        // 调用获取上级页面发送事件的微信内置方法
        const eventChannel = this.getOpenerEventChannel();
        // 获取当前书籍信息
        eventChannel.on('getTheBookInfo', function (data) {
            const noteList_strLine = data.noteList.replace(/\n+/gm, '\\n');
            // 单独获取笔记列表
            const noteList = JSON.parse(noteList_strLine);
            const noteCount = noteList.length;

            _this.setData({
                bookInfo: data,
                noteList: noteList,
                noteCount: noteCount
            });

            // 根据书名设置标题内容
            wx.setNavigationBarTitle({
                title: data.bookName 
            });
        });
        // 获取接口文件名称
        eventChannel.on('getApiFile', function (data) {
            _this.setData({
                // 设置接口文件名称对象
                apifile: data
            });
        });
    },

    /**
     * 获取表单输入的值
     */
    getInputValue(e) {
        // 获取当前输入框的 data-name
        const dataName = e.currentTarget.dataset.name;
        // 获取当前输入框输入值
        const val = e.detail.value;

        const tempData = {
            article: this.data.note.article,
            section: this.data.note.section,
            title: this.data.note.title,
            content: this.data.note.content,
            create_date: this.data.note.create_date
        };
        tempData[dataName] = val;

        this.setData({
            note: tempData
        });
    },

    /**
     * 添加笔记按钮功能 
     */
    booknoteAdd(e) {
        // 获取当前笔记的ID
        const bookID = this.data.bookInfo.book_ID;

        const tempData = {
            article: this.data.note.article,
            section: this.data.note.section,
            title: this.data.note.title,
            content: this.data.note.content,
            create_date: this.getStandardDatetime()
        }

        // 调用数据验证方法，如果返回了 false，则中断操作
        if(!this.dataValid(tempData)) {
            return false;
        }

        // 克隆 nodeList 数据
        const notes = [].concat(this.data.noteList);
        
        // 添加当前输入完成的对象
        notes.push(tempData);

        // 获取当前笔记的个数
        const noteCount = notes.length;

        // 设置实时数据
        this.setData({
            noteList: notes,
            noteCount: noteCount
        });

        // 调用更新书籍笔记数组字段的方法
        this.updateNodeListData(bookID, notes);
    },

    /**
     * 准备修改笔记按钮的功能
     * @param { Object } e 按钮事件对象
     */
    booknoteEdit(e) {
        // 获取当前笔记的数据设置
        const data = e.currentTarget.dataset;
        // 获取笔记在数组内的索引值
        const index = data.index;
        // 获取笔记内容信息的对象
        const info = data.item;

        this.setData({
            // 设置表单按钮状态为“修改笔记”
            noteState_add: false,
            // 显示表单面板
            booknoteAddPannel_show: true,
            note: {
                article: info.article,
                section: info.section,
                title: info.title,
                content: info.content,
                create_date: info.create_date
            },
            // 设置当前索引值
            noteIndex: index
        });
    },

    // 保存修改后的笔记
    booknoteSave() {
        // 获取书籍对象
        const theBook = this.data.bookInfo;
        // 获取当前笔记的ID
        const bookID = theBook.book_ID;

        // 创建临时数据对象
        const tempData = Object.assign({}, this.data.note);

        // 调用数据验证方法，如果返回了 false，则中断操作
        if(!this.dataValid(tempData)) {
            return false;
        }

        const noteList_strLine = theBook.noteList.replace(/\n+/gm, '\\n');
        // 获取当前书籍的 noteList
        const theNoteList = JSON.parse(noteList_strLine);

        // 更新当前页面 data 内的笔记数据
        theNoteList.splice(
            this.data.noteIndex,
            1,
            tempData
        );
        this.setData({
            noteList: theNoteList
        });
        setTimeout(() => {
            // 调用更新书籍笔记数组字段的方法
            this.updateNodeListData(bookID, theNoteList);
        },100);
        
    },

    /**
     * 表单输入非空验证
     * @param { Object } tempData 表单输入的临时对象
     */
    dataValid(tempData) {
        // 数据验证——章数
        if(!tempData.article.trim()) {
            wx.showToast({
                title: '书籍章数必须填写',
                icon: 'none',
                duration: 2000
            })
            return false;
        }
        // 数据验证——章数（数字验证）
        if(!/^[0-9]+$/g.test(tempData.article.trim())) {
            wx.showToast({
                title: '书籍章数必须为数字',
                icon: 'none',
                duration: 2000
            })
            return false;
        }
        // 数据验证——节数
        if(!tempData.section.trim()) {
            wx.showToast({
                title: '书籍节数必须填写',
                icon: 'none',
                duration: 2000
            })
            return false;
        }
        // 数据验证——节数（数字验证）
        if(!/^[0-9]+$/g.test(tempData.section.trim())) {
            wx.showToast({
                title: '书籍节数必须为数字',
                icon: 'none',
                duration: 2000
            })
            return false;
        }
        // 数据验证——笔记标题
        if(!tempData.title.trim()) {
            wx.showToast({
                title: '笔记标题必须填写',
                icon: 'none',
                duration: 2000
            })
            return false;
        }
        // 数据验证——笔记内容
        if(!tempData.content.trim()) {
            wx.showToast({
                title: '笔记内容必须填写',
                icon: 'none',
                duration: 2000
            })
            return false;
        }
        return true;
    },

    /**
     * 删除当前笔记的功能
     * @param { Object } e 按钮事件对象
     */
    booknoteDel(e) {
        // 获取当前笔记的ID
        const bookID = this.data.bookInfo.book_ID;
        // 获取当前笔记的数据设置
        const data = e.currentTarget.dataset;
        // 获取笔记在数组内的索引值
        const index = data.index;

        const _this = this;
        // 调用确认对话框
        wx.showModal({
            content: '确定要删除该条笔记吗？',
            confirmColor: '#9c1308',
            success(res) {
                if (res.confirm) {
                    // 更新当前页面 data 内的笔记数据
                    _this.data.noteList.splice(index, 1);
                    _this.setData({
                        noteList: _this.data.noteList
                    });
                    // 调用更新书籍笔记数组字段的方法
                    _this.updateNodeListData(bookID, _this.data.noteList);
                }
                // 取消删除操作
                else if (res.cancel) {
                    // 暂时什么都不做
                }
            }
        });
    },

    /**
     * 加载书籍数据功能 
     */
    loadBookData() {
        const _this = this;
        // 获取 apifile 对象
        const apifile = this.data.apifile;

        // 请求书籍信息的AJAX配置
        wx.request({
            method: 'GET',
            url: `${BaseURL}${apifile.getInfo}`,
            dataType: 'json',
            data: {
                databaseName: apifile.databaseName,
            },
            header: {
                'content-type': 'application/json'
            },
            success(res) {
                // 将数据传递至上级页面
                const eventChannel = _this.getOpenerEventChannel()
                eventChannel.emit('acceptDataFromOpenedPage', res.data);

                // 获取当前笔记的对象
                const currentBook = res.data.filter((obj) => {
                    return obj.book_ID === _this.data.bookInfo.book_ID;
                });
                // 转换当前书籍的数据格式
                const bookObj = currentBook[0];
                _this.setData({
                    // 重新设置 nodeList 的数据
                    nodeList: bookObj.nodeList
                });
            }
        });
    },

    /**
     * 更新书籍笔记数组字段的方法
     * @param { String } bookID 当前书籍的ID
     * @param { Array } notes 当前书籍笔记的列表
     */
    updateNodeListData(bookID,notes) {
        // 获取 this
        const _this = this;
        // 获取 apifile 对象
        const apifile = this.data.apifile;

        // 通过笔记添加接口单独对 noteList 字段进行更新
        wx.request({
            method: 'POST',
            url: `${BaseURL}${apifile.noteAdd}`,
            dataType: 'text',
            data: {
                book_ID: bookID,
                databaseName: apifile.databaseName,
                noteList: JSON.stringify(notes)
            },
            header: {
                'content-type': 'application/x-www-form-urlencoded'
            },
            success(res) {
                // 显示返回信息
                wx.showToast({
                    title: '操作成功！',
                    icon: 'success',
                    duration: 2500
                });

                // 隐藏表单面板，并重置数据
                _this.setData({
                    booknoteAddPannel_show: false,
                    note: {
                        article: '',
                        section: '',
                        title: '',
                        content: ''
                    }
                });

                // 加载最新的数据
                _this.loadBookData();
            }
        });
    },

    /**
     * 显示笔记详情信息
     * @param { Object } even 当前笔记事件对象
     */
    showNoteInfo(even) {
        // 获取当前笔记对象信息
        const noteInfo = even.currentTarget.dataset.item;

        this.setData({
            dialogInfo: {
                article: noteInfo.article,
                section: noteInfo.section,
                title: noteInfo.title,
                content: noteInfo.content,
                create_date: noteInfo.create_date
            },
            dialogInfoShow: true
        });
    },

    /**
     * 关闭书籍信息对话框组件方法
     */
    hideDialog() {
        this.setData({
            dialogInfoShow: false
        });
    },

    /**
     * 显示笔记添加面板
     */
    showAddpannel() {
        // 将面板显示状态设置为 true
        this.setData({
            noteState_add: true,
            booknoteAddPannel_show: true
        });
    },

    /**
     * 显示笔记添加面板（取消按钮）
     */
    hideAddpannel() {
        // 重置数据
        this.setData({
            booknoteAddPannel_show: false,
            note: {
                article: '',
                section: '',
                title: '',
                content: ''
            },
            noteIndex: 9999
        });
    },

    /**
     * 格式化时间功能
     * @param { Date } datetime 
     */
    getStandardDatetime(datetime) {
        // 格式化时间
        const formatTime = date => {
            const year = date.getFullYear()
            const month = date.getMonth() + 1
            const day = date.getDate()
            const hour = date.getHours()
            const minute = date.getMinutes()
            const second = date.getSeconds()
            return [year, month, day].map(formatNumber).join('/') + ' ' + [hour, minute, second].map(formatNumber).join(':')
        }

        // 补零操作
        const formatNumber = n => {
            n = n.toString()
            return n[1] ? n : '0' + n;
        }

        // 传入参数并运行
        return datetime ? formatTime(new Date(datetime)) : formatTime(new Date());
    }

})